package com.demo.java.OD151_200.OD188;

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * @author bug菌
 * @Source 公众号：猿圈奇妙屋
 * @des： 【对称美学，对称字符串】问题
 * @url： https://blog.csdn.net/weixin_43970743/article/details/145880980
 */
public class OdMain {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(new BufferedInputStream(System.in));

        int sl = scanner.nextInt(); // 读取测试用例的数量

        Solution solution = new Solution();

        // 根据输入的数量循环处理
        for (int i = 0; i < sl; i++) {
            long a = scanner.nextLong(); // 读取 a
            double b = scanner.nextDouble(); // 读取 b

            // 调用 Solution 对象的 getResult 方法获得结果，并打印对应的颜色
            if (solution.getResult(a, b) == 'R') {
                System.out.println("red");
            } else {
                System.out.println("blue");
            }
        }
    }

    public static class Solution {
        // 判断颜色的递归函数
        char getResult(long a, double b) {
            if (a == 1) {
                // 当 a 为 1 时，结果为 'R'
                return 'R';
            }
            if (a == 2) {
                if (b == 0) {
                    // 当 a 为 2，且 b 为 0 时，结果为 'B'
                    return 'B';
                } else {
                    // 当 a 为 2，且 b 不为 0 时，结果为 'R'
                    return 'R';
                }
            }
            // 计算 sz 的值
            double sz = calculatePow(a);
            if (b < sz) {
                // 当 b 小于 sz 时，递归调用 getResult 方法，继续计算结果
                if (getResult(a - 1, b) == 'R') {
                    return 'B';
                } else {
                    return 'R';
                }
            }
            if (b >= sz) {
                // 当 b 大于等于 sz 时，计算 index 的值，然后递归调用 getResult 方法，继续计算结果
                double index = b - sz;
                return getResult(a - 1, index);
            }
            return '0'; // 默认返回
        }

        // 计算 pow 的值
        double calculatePow(long x) {
            return 1L << (x - 2);
        }
    }
}